package csd.wyaiyr.com.utils;

import lombok.extern.slf4j.Slf4j;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

/**
 * @Description 时期格式化通用类
 */
@Slf4j
public class DateUtil {

    private static SimpleDateFormat sdf = null;

    private static boolean flag = true;

    private static long timeVal = 0;   //存放时间毫秒值变量
    public static String DateMode_1 = "yyyy-MM-dd";
    public static String DateMode_2 = "yyyy-MM-dd HH:mm";
    public static String DateMode_3 = "yyyyMMddHHmmssSSS";
    public static String DateMode_4 = "yyyy-MM-dd HH:mm:ss";
    public static String DateMode_5 = "HHmmssSS";
    public static String DateMode_6 = "yyyyMMdd";
    public static String DateMode_7 = "HHmmss";
    public static String DateMode_8 = "yyyy";
    public static String DateMode_9 = "yyyyMMddHHmmss";
    public static String DateMode_10 = "HH:mm:ss";
    public static String DateMode_11 = "yyyy-MM-dd HH:mm:ss.SSS";
    public static String DateMode_12 = "HH:mm";
    public static String DateMode_13 = "HH";
    public static String DateMode_14 = "yyyyMM";
    public static String DateMode_15 = "yyyy-MM";
    public static Date showDate = convertToStandardDate("2014-12-07 21:30:00");
    public static final String NORM_DATETIME_MINUTE_PATTERN = "yyyy-MM-dd HH";
    /**
     * 年月日时分秒(无下划线) yyyyMMddHHmmss
     */
    public static final String dtLong = "yyyyMMddHHmmss";

    /**
     * 完整时间 yyyy-MM-dd HH:mm:ss
     */
    public static final String simple = "yyyy-MM-dd HH:mm:ss";

    /**
     * 年月日(无下划线) yyyyMMdd
     */
    public static final String dtShort = "yyyyMMdd";

    public static final String yyyy = "yyyy";

    /**
     * 转换为当前小时整点，格式为yyyy-MM-dd HH:00:00
     *
     * @param time
     * @return
     */
    public static String formatToIntegralTime(Date time) {
        return formatToHour(time) + ":00:00";
    }

    /**
     * 格式化成  yyyy-MM-dd HH:mm:ss
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatStandardTime(Date time) {
        sdf = new SimpleDateFormat(simple);
        return sdf.format(time);
    }

    /**
     * 格式化成  yyyy-MM-dd HH:mm
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatStandardHourAndMinute(Date time) {
        sdf = new SimpleDateFormat(DateMode_2);
        return sdf.format(time);
    }
    /**
     * 格式化成  yyyy
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatToYear(Date time) {

        sdf = new SimpleDateFormat(yyyy);

        return sdf.format(time);
    }

    /**
     * 格式化成  yyyy-MM
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatToMonth(Date time) {

        sdf = new SimpleDateFormat("yyyy-MM");

        return sdf.format(time);
    }

    /**
     * 格式化成  yyyy-MM-dd
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatToDay(Date time) {

        sdf = new SimpleDateFormat("yyyy-MM-dd");

        return sdf.format(time);
    }

    /**
     * 格式化成  yyyy-M-d
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatToDate(Date time) {

        sdf = new SimpleDateFormat("yyyy-M-d");

        return sdf.format(time);
    }

    /**
     * 格式化成  yyyy.M.d
     *
     * @param time Date型时间
     * @return string型时间
     * @author 黄丽
     * @since 2016-11-10
     */
    public static String formatToDayOne(Date time) {

        sdf = new SimpleDateFormat("yyyy.M.d");

        return sdf.format(time);
    }

    /**
     * 将时间字符串转为Date型,格式yyyy-M-d
     *
     * @param time String型时间
     * @return Date型时间
     */
    public static Date convertToDay(String time) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-M-d");
        Date date = null;
        try {
            date = sdf.parse(time);
        } catch (ParseException e) {

        }
        return date;
    }

    /**
     * 将时间字符串转为Date型,格式yyyy-M-d
     *
     * @param time String型时间
     * @return Date型时间
     */
    public static Date getDateByTimeStr(String time) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = null;
        try {
            date = sdf.parse(time);
        } catch (ParseException e) {

        }
        return date;
    }

    /**
     * 格式化成  yyyy-MM-dd HH
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatToHour(Date time) {
        sdf = new SimpleDateFormat("yyyy-MM-dd HH");
        return sdf.format(time);
    }

    /**
     * 获取分钟
     * 格式化成  mm
     * @param time
     * @return
     */
    public static String getMinute(Date time) {
        sdf = new SimpleDateFormat("mm");
        return sdf.format(time);
    }
    /**
     * 格式化成 HH:mm
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatToMinute(Date time) {
        sdf = new SimpleDateFormat("HH:mm");
        return sdf.format(time);
    }

    /**
     * 取日期的小时
     *
     * @param time
     * @return
     */
    public static String getHour(Date time) {
        sdf = new SimpleDateFormat("HH");
        return sdf.format(time);
    }

    /**
     * 格式化成  MM-dd
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatToMonthDay(Date time) {

        sdf = new SimpleDateFormat("MM-dd");

        return sdf.format(time);
    }

    /**
     * 格式化成  MM-dd HH:mm
     * @param time
     * @return
     */
    public static String formatToMonthDayHourMinute(Date time) {

        sdf = new SimpleDateFormat("MM-dd HH:mm");

        return sdf.format(time);
    }
    /**
     * 格式化成  mm:ss
     *
     * @param time Date型时间
     * @return string型时间
     */
    public static String formatToMinuteSecond(Date time) {

        sdf = new SimpleDateFormat("mm:ss");

        return sdf.format(time);
    }

    /**
     * 将时间字符串转为Date型,格式yyyy-MM-dd
     *
     * @param time String型时间
     * @return Date型时间
     */
    public static Date convertToDate(String time) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = sdf.parse(time);
        } catch (ParseException e) {

        }
        return date;
    }


    public static Date convertToDateTime(String time) {
        SimpleDateFormat sdf = new SimpleDateFormat(DateMode_4);
        Date date = null;
        try {
            date = sdf.parse(time);
        } catch (ParseException e) {

        }
        return date;
    }

    public static Date convertToMonth(String month) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        Date date = null;
        try {
            date = sdf.parse(month);
        } catch (ParseException e) {

        }
        return date;
    }

    /**
     * 将时间字符串转为Date型,格式yyyy-MM-dd HH:mm:ss
     *
     * @param time String型时间
     * @return Date型时间
     */
    public static Date convertToStandardDate(String time) {
        Date date = null;
        sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            date = sdf.parse(time);
        } catch (ParseException e) {

        }
        return date;
    }
    /**
     * 将时间字符串转为Date型,格式yyyy-MM-dd HH:mm
     *
     * @param time String型时间
     * @return Date型时间
     */
    public static Date convertToStandardDateNotSecond(String time) {
        Date date = null;
        sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        try {
            date = sdf.parse(time);
        } catch (ParseException e) {

        }
        return date;
    }
    /**
     * 将时间字符串转为Date型,格式yyyy-MM-dd HH
     *
     * @param time String型时间
     * @return Date型时间
     */
    public static Date convertToDateHour(String time) {
        Date date = null;
        sdf = new SimpleDateFormat("yyyy-MM-dd HH");
        try {
            date = sdf.parse(time);
        } catch (ParseException e) {

        }
        return date;
    }
    /**
     * 返回系统当前时间
     *
     * @return Date型
     */
    public static Date getNowTime() {
        return new Date(System.currentTimeMillis());
    }

    /**
     * 将传入时间增加一个小时
     *
     * @param date Date型时间
     * @return String型时间，格式yyyy-MM-dd HH:mm:ss
     */
    public static String addOneHour(Date date) {
        timeVal = date.getTime() + 60 * 60 * 1000;
        return formatStandardTime(new Date(timeVal));
    }

    /**
     * 将传入时间增加N个小时
     *
     * @param date Date型时间
     * @return String型时间，格式yyyy-MM-dd HH:mm:ss
     */
    public static String addNHour(Date date,Integer n) {
        timeVal = date.getTime() + n * 60 * 60 * 1000;
        return formatStandardTime(new Date(timeVal));
    }



    /**
     * 将传入时间减去一个小时，返回String型结果
     *
     * @param date Date型时间
     * @return String型时间，格式yyyy-MM-dd HH:mm:ss
     */
    public static String subOneHour(Date date) {
        timeVal = date.getTime() - 60 * 60 * 1000;
        return formatStandardTime(new Date(timeVal));
    }

    /**
     * 将传入时间减去一个小时，返回Date型结果
     *
     * @param date Date型时间
     * @return Date型时间
     */
    public static Date subOneHourToDate(Date date) {
        timeVal = date.getTime() - 60 * 60 * 1000;
        return new Date(timeVal);
    }

    /**
     * 比较两个时间大小
     *
     * @param startTime String
     * @param endTime   String
     * @return flag boolean值
     */
    public static boolean compareDate(String startTime, String endTime) {
        if (convertToDate(startTime).getTime() <= convertToDate(endTime)
                .getTime()) {
            flag = true;
        } else {
            flag = false;
        }
        return flag;
    }

    /**
     * 给时间增加指定天数
     *
     * @param time   String
     * @param dayNum 需要增加的天数 int值
     * @return String 格式 yyyy-MM-dd
     */
    public static String addDays(String time, int dayNum) {
        timeVal = convertToDate(time).getTime() + 1000 * 60 * 60 * 24 * dayNum;
        return formatToDay(new Date(timeVal));
    }

    /**
     * 减少指定天数
     *
     * @param time   Date
     * @param dayNum 需要减少的天数 int值
     * @return String 格式 yyyy-MM-dd
     */
    public static String subDateDays(Date time, int dayNum) {

        Calendar date = Calendar.getInstance();

        date.setTime(time);

        date.set(Calendar.DATE, date.get(Calendar.DATE) - dayNum);
        Date timeVal = date.getTime();
        return formatToDay(timeVal);
    }

    /**
     * 给时间减少指定天数
     *
     * @param time   Date
     * @param dayNum 需要减少的天数 int值
     * @return String 格式 yyyy-MM-dd
     */
    public static String subDays(Date time, int dayNum) {
        timeVal = time.getTime() - 1000 * 60 * 60 * 24 * dayNum;
        return formatToDay(new Date(timeVal));
    }

    /**
     * 给时间减少指定天数
     *
     * @param time
     * @param dayNum
     * @return String 格式yyyy-MM-dd HH:mm:ss
     */
    public static String subDaysWithSecond(Date time, int dayNum) {
        timeVal = time.getTime() - 1000 * 60 * 60 * 24 * dayNum;
        return formatStandardTime(new Date(timeVal));
    }

    /**
     * 将传入时间减去一个小时
     *
     * @param date
     * @return
     */
    public static String subOneHourWithH(Date date) {
        timeVal = date.getTime() - 60 * 60 * 1000;
        return formatToHour(new Date(timeVal));
    }

    /**
     * 计算两个日期的天数
     */
    public static int diffTwoDate(String startDate, String endDate) {
        sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date d1 = sdf.parse(startDate);
            Date d2 = sdf.parse(endDate);
            Calendar cal = Calendar.getInstance();
            cal.setTime(d1);
            long time1 = cal.getTimeInMillis();
            cal.setTime(d2);
            long time2 = cal.getTimeInMillis();
            Long betweenDays = (time2 - time1) / (1000 * 3600 * 24);

            return Integer.valueOf(betweenDays.toString());
        } catch (Exception e) {

        }
        return 0;
    }

    /**
     * 获得两个日期之间的日期(日期包括起始时间和结束时间)
     *
     * @param startTime
     * @param endTime
     * @return
     * @throws ParseException
     */
    public static List<String> getDateList(String startTime, String endTime) {
        List<String> dateList = new ArrayList<>();
        Calendar startCalendar = Calendar.getInstance();
        Calendar endCalendar = Calendar.getInstance();
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date startDate = df.parse(startTime);
            startCalendar.setTime(startDate);
            Date endDate = df.parse(endTime);
            endCalendar.setTime(endDate);
            dateList.add(startTime);
            while (true) {
                startCalendar.add(Calendar.DAY_OF_MONTH, 1);
                if (startCalendar.getTimeInMillis() <= endCalendar.getTimeInMillis()) {
                    dateList.add(new SimpleDateFormat("yyyy-MM-dd").format(startCalendar.getTime()));
                } else {
                    break;
                }

            }
        } catch (Exception e) {

        }
        return dateList;
    }

    /**
     * 取得当月天数
     */
    public static int getCurrentDays() {
        Calendar a = Calendar.getInstance();
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 获取当前月份
     */
    public static int getCurrentMonth() {
        Calendar a = Calendar.getInstance();
        int maxMonth = a.get(Calendar.MONTH) + 1;
        return maxMonth;
    }

    /**
     * 取得当月最后一天日期
     */
    public static int getCurrentMonthLastDay() {
        Calendar a = Calendar.getInstance();
        a.set(Calendar.DATE, 1);//把日期设置为当月第一天
        a.roll(Calendar.DATE, -1);//日期回滚一天，也就是最后一天
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 得到指定月的天数
     *
     * @param year  年份
     * @param month 月份
     */
    public static int getMonthLastDay(int year, int month) {
        Calendar a = Calendar.getInstance();
        a.set(Calendar.YEAR, year);
        a.set(Calendar.MONTH, month - 1);
        a.set(Calendar.DATE, 1);//把日期设置为当月第一天
        a.roll(Calendar.DATE, -1);//日期回滚一天，也就是最后一天
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 得到指定月的天数
     *
     * @param monthOfYear 月份 例如：2015-11
     */
    public static int getMonthLastDay(String monthOfYear) {
        int year = Integer.valueOf(monthOfYear.substring(0, 4));
        int month = Integer.valueOf(monthOfYear.substring(4));

        Calendar a = Calendar.getInstance();
        a.set(Calendar.YEAR, year);
        a.set(Calendar.MONTH, month - 1);
        a.set(Calendar.DATE, 1);//把日期设置为当月第一天
        a.roll(Calendar.DATE, -1);//日期回滚一天，也就是最后一天
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 返回当前系统时间 yyyy-MM-dd HH:mm:ss
     */
    public static String getNowDateString() {
        Date currentTime = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return formatter.format(currentTime);
    }

    /**
     * 返回当前系统时间 yyyyMMddHHmmss
     */
    
    public static String getNowDateStrings() {
        Date currentTime = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
        return formatter.format(currentTime);
    }

    /**
     * 判断日期字符串是否严格符合日期格式
     *
     * @param date--日期字符串
     * @param dateFormat--日期格式(例如：yyyy-MM-dd)
     * @return true--格式正确  false--格式错误
     */
    public static boolean checkDateFormat(String date, String dateFormat) {
        boolean convertSuccess = true;
        // 指定日期格式
        SimpleDateFormat format = new SimpleDateFormat(dateFormat);
        try {
            // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
            format.setLenient(false);
            format.parse(date);
        } catch (Exception e) {
            //
            // 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
            convertSuccess = false;
        }
        return convertSuccess;
    }

    /**
     * 比较两个时间是否相差大于指定时间
     *
     * @param startTime String
     * @param endTime   String
     * @return flag boolean值
     */
    public static boolean compareDateReduce(String startTime, String endTime, long reduce) {
        long a = convertToStandardDate(endTime).getTime() - convertToStandardDate(startTime).getTime();
        if (a > reduce) {
            flag = true;
        } else {
            flag = false;
        }
        return flag;
    }


    /**
     * 返回系统当前时间(精确到毫秒),作为一个唯一的订单编号
     *
     * @return 以yyyyMMddHHmmss为格式的当前系统时间
     */
    public static String getOrderNum() {
        Date date = new Date();
        DateFormat df = new SimpleDateFormat(dtLong);
        return df.format(date);
    }

    /**
     * 获取系统当前日期(精确到毫秒)，格式：yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String getDateFormatter() {
        Date date = new Date();
        DateFormat df = new SimpleDateFormat(simple);
        return df.format(date);
    }

    /**
     * 获取系统当期年月日(精确到天)，格式：yyyyMMdd
     *
     * @return
     */
    public static String getDate() {
        Date date = new Date();
        DateFormat df = new SimpleDateFormat(dtShort);
        return df.format(date);
    }

    /**
     * 返回指定格式的系统当前日期时间
     */
    public static String getDateAndTime(String fomat) {
        SimpleDateFormat today;
        today = new SimpleDateFormat(fomat);
        return today.format(new Date());
    }

    /**
     * 返回指定格式的时间
     */
    public static String getDateAndTime(Date date, String fomat) {
        SimpleDateFormat today;
        today = new SimpleDateFormat(fomat);
        return today.format(date);
    }

    /**
     * 返回系统当前日期 格式为 YYYY-MM-dd
     *
     * @return String YYYY-MM-dd
     */
    public static String getShortDate() {
        return getDateAndTime("yyyy-MM-dd");
    }

    /**
     * 按照指定的格式,格式化指定的日期
     *
     * @return String 格式化好的字符串
     */
    public static String formatDate(Date pidate, String strFormat) {
        SimpleDateFormat simpledateformat = new SimpleDateFormat(strFormat);
        String str = simpledateformat.format(pidate);
        return str;
    }

    /**
     * 按照指定的格式,转化字符串为日期
     *
     * @return Date 转换好的日期
     */
    public static Date strToDate(String str, String strFormat) {
        Date reDate = null;
        SimpleDateFormat simpledateformat = new SimpleDateFormat(strFormat);
        try {
            reDate = simpledateformat.parse(str);
        } catch (Exception e) {
            //Common.log("无效的日期字符串");
        }
        return reDate;
    }

    /**
     * 在某一日期上增加天数，返回多少天以后的日期
     *
     * @return Date 增加天数以后的日期
     */
    public static Date addDay(Date date, long days) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(5, (int) days);
        Date date1 = calendar.getTime();
        return date1;
    }

    /**
     * 在某一日期上增加分钟数，返回多少分钟以后的日期
     *
     * @return Date 增加分钟数以后的日期
     */
    public static Date addMinute(Date pidate, long minutes) {
        long adate = pidate.getTime() + minutes * 60 * 1000;
        return new Date(adate);
    }

    /**
     * 取得两个日期之间的差值
     *
     * @return long 两个日期之间的差值，类型是微秒
     */
    public static long dateDiff(Date pidate1, Date pidate2) {
        return pidate1.getTime() - pidate2.getTime();
    }

    /**
     * 取得两个日期之间的差值
     *
     * @return long 两个日期之间的差值，类型由第一个String参数指定
     */
    public static long dateDiff(String style, Date fromdate, Date todate) {
        byte byte0;
        byte byte1 = 0;
        int i = 1;
        Date date2;
        Date date3;
        if (fromdate.getTime() > todate.getTime()) {
            i = -1;
            date2 = todate;
            date3 = fromdate;
        } else {
            date2 = fromdate;
            date3 = todate;
        }
        if (style.equals("yyyy"))//年
            byte0 = 1;
        else if (style.equals("m"))//月
            byte0 = 2;
        else if (style.equals("d"))//日
            byte0 = 5;
        else if (style.equals("y"))
            byte0 = 5;
        else if (style.equals("w"))
            byte0 = 4;
        else if (style.equals("ww"))
            byte0 = 3;
        else if (style.equals("h")) {
            byte0 = 5;
            byte1 = 11;
        } else if (style.equals("n")) {
            byte0 = 5;
            byte1 = 12;
        } else if (style.equals("s")) {
            byte0 = 5;
            byte1 = 13;
        } else {
            return -1;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date2);
        long l = 0;
        calendar.add(byte0, 1);
        for (Date date4 = calendar.getTime(); date4.getTime() <= date3.getTime(); ) {
            calendar.add(byte0, 1);
            date4 = calendar.getTime();
            l++;
        }
        if (byte1 == 11 || byte1 == 12 || byte1 == 13) {
            calendar.setTime(date2);
            calendar.add(byte0, (int) l);
//            Date date5 = calendar.getTime();
            switch (byte1) {
                case 11:
                    l *= 24;
                    break;
                case 12:
                    l = l * 24 * 60;
                    break;
                case 13:
                    l = l * 24 * 60 * 60;
                    break;
            }
            calendar.add(byte1, 1);
            for (Date date6 = calendar.getTime(); date6.getTime() <= date3.getTime(); ) {
                calendar.add(byte1, 1);
                date6 = calendar.getTime();
                l++;
            }
        }
        return l * i;
    }

    /**
     * 返回当前时间和当日最后时间的差值
     *
     * @param style 返回类型是秒（s）
     * @return
     */
    public static long compareTodayFinishTime(String style) {
        Date date = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        String time = formatter.format(date);

        String todayTime = time + " 23:59:59";
        Date today = convertToStandardDate(todayTime);

        long s = dateDiff(style, date, today);
        return s;
    }

    /**
     * 取得指定日期所在的星期
     *
     * @param date 指定的日期
     * @return int 所在的星期
     */
    public static int getWeekDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(7);
    }


    /**
     * 获取本月的第一天  yyyy-MM-dd
     * @return
     */
    public static String getMonthFirstDay(){
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH,1);
        calendar.add(Calendar.MONTH,0);
        return new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime());
    }

    /**
     * 获取本月的最后一天 yyyy-MM-dd
     * @return
     */
    public static String getMonthLastDay(){
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        return new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime());
    }

    /**
     * 获取当月的每一天 yyyy-MM-dd
     */
    public  static List<String> getCurrMonthEveryDay(){
        List<String> dateList = DateUtil.getDateList(DateUtil.getMonthFirstDay(), DateUtil.getMonthLastDay());
        return dateList;
    }

//    /**
//     * 获取指定月的每一天 yyyy-MM-dd
//     */
//    public  static List<String> getMonthEveryDay(String yyyyMM){
//
//        List<String> dateList = DateUtil.getDateList(DateUtil.getMonthFirstDay(), DateUtil.getMonthLastDay());
//        return dateList;
//    }

    /**
     * 获取指定日期所在月份的每一天
     * @param date
     * @return
     */
    public static List<String> getDayListOfMonth(Date date) {
        List<String> list = new ArrayList<String>();
        Calendar aCalendar = Calendar.getInstance();
        aCalendar.setTime(date);
        int year = aCalendar.get(Calendar.YEAR);//年份
        int month = aCalendar.get(Calendar.MONTH) + 1;//月份
        int day = aCalendar.getActualMaximum(Calendar.DATE);
        for (int i = 1; i <= day; i++) {
            String aDate = String.valueOf(year) + "-" + String.format("%02d", month) + "-" + String.format("%02d", i);
            list.add(aDate);
        }
        return list;
    }

    /**
     * /**
     * 转换日期型数据为指定格式字符串
     *
     * @param date
     * @param pattern
     * @return
     */
    public static String D2S(Date date, String pattern) {
        if (null == date) {
            return "";
        }
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        return format.format(date);
    }

    /**
     * 根据出生日期获取年龄   23,岁 月 天
     */
    public static String getAgeByBrithday(Date birthDay) {
        String age = "";
        DateFormat simple = new SimpleDateFormat("yyyy-MM-dd");
        String[] darqArr = simple.format(new Date()).split("-");
        String[] csrqArr = simple.format(birthDay).split("-");
        Long csn = Long.parseLong(csrqArr[0]);
        Long dqn = Long.parseLong(darqArr[0]);
        Long csy = Long.parseLong(csrqArr[1]);
        Long dqy = Long.parseLong(darqArr[1]);
        Long csd = Long.parseLong(csrqArr[2]);
        Long dqd = Long.parseLong(darqArr[2]);
        if (dqn.longValue() > csn.longValue()) {
            return age + (dqn - csn) + "-1-岁";
        } else if (dqn.longValue() == csn.longValue() && dqy.longValue() > csy.longValue()) {
            return age + (dqy - csy) + "-2-月";
        } else if (dqn.longValue() == csn.longValue() && dqy.longValue() == csy.longValue() && dqd.longValue() > csd.longValue()) {
            return age + (dqd - csd) + "-3-天";
        } else {
            return age + "出生日期可能有误";
        }
    }

    /**
     * 根据出生日期获取年龄   23,岁 月 天
     */
    public static String getAgeByBrithdayNoBm(Date birthDay) {
        String age = "";
        DateFormat simple = new SimpleDateFormat("yyyy-MM-dd");
        String[] darqArr = simple.format(new Date()).split("-");
        String[] csrqArr = simple.format(birthDay).split("-");
        Long csn = Long.parseLong(csrqArr[0]);
        Long dqn = Long.parseLong(darqArr[0]);
        Long csy = Long.parseLong(csrqArr[1]);
        Long dqy = Long.parseLong(darqArr[1]);
        Long csd = Long.parseLong(csrqArr[2]);
        Long dqd = Long.parseLong(darqArr[2]);
        if (dqn.longValue() > csn.longValue()) {
            return age + (dqn - csn) + "岁";
        } else if (dqn.longValue() == csn.longValue() && dqy.longValue() > csy.longValue()) {
            return age + (dqy - csy) + "月";
        } else if (dqn.longValue() == csn.longValue() && dqy.longValue() == csy.longValue() && dqd.longValue() > csd.longValue()) {
            return age + (dqd - csd) + "天";
        } else {
            return age + "出生日期可能有误";
        }
    }

    /**
     * 计算两个日期相差月数
     *
     * @param date1
     * @param date2
     * @return
     * @throws ParseException
     */
    public static int getMonthSpace(String date1, String date2)
            throws ParseException {

        int result = 0;

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();

        c1.setTime(sdf.parse(date1));
        c2.setTime(sdf.parse(date2));

        result = c2.get(Calendar.MONTH) - c1.get(Calendar.MONTH);

        return result == 0 ? 0 : Math.abs(result);

    }

    /**
     * 判断当前时间是否在[startTime, endTime]区间，注意时间格式要一致
     *
     * @param nowTime   当前时间
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return
     */
    public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
        if (nowTime.getTime() == startTime.getTime()
                || nowTime.getTime() == endTime.getTime()) {
            return true;
        }

        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);

        Calendar begin = Calendar.getInstance();
        begin.setTime(startTime);

        Calendar end = Calendar.getInstance();
        end.setTime(endTime);

        if (date.after(begin) && date.before(end)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 根据开始日期和结束日期计算中间所有日期
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static List<Date> findDates(Date startDate, Date endDate) {
        List<Date> allDate = new ArrayList();
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(startDate);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(endDate);
        // 测试此日期是否在指定日期之后
        while (endDate.after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            allDate.add(calBegin.getTime());
            calBegin.add(Calendar.DAY_OF_MONTH, 1);
        }
        return allDate;
    }

    /**
     * 获取两个日期之间的所有小时集合
     *
     * @param startDateStr
     * @param endDateStr
     * @return
     * @throws Exception
     */
    public static List<Date> getHourList(String startDateStr, String endDateStr) {
        List<Date> list = new ArrayList<>();
        DateFormat simpleDateFormat = new SimpleDateFormat(DateMode_2);
        try {
            Date startDate = simpleDateFormat.parse(startDateStr); // 开始日期
            Date endDate = simpleDateFormat.parse(endDateStr); //结束日期
            Calendar startCalendar = Calendar.getInstance();
            Calendar endCalendar = Calendar.getInstance();
            startCalendar.setTime(startDate);
            endCalendar.setTime(endDate);
            while (startCalendar.compareTo(endCalendar) <= 0) {
                list.add(startCalendar.getTime());
                // 开始日期加一个小时直到等于结束日期为止
                startCalendar.add(Calendar.HOUR, 1);
            }
        } catch (ParseException e) {

        }
        return list;
    }

    /**
     * 获取两个日期之间的所有小时集合 不包含结束日期对应的小时，返回string 类型
     * @param startDateStr
     * @param endDateStr
     * @return
     */
    public static List<String> getHourListToString(String startDateStr, String endDateStr) {
        List<String> list = new ArrayList<>();
        DateFormat simpleDateFormat = new SimpleDateFormat(DateMode_2);
        DateFormat format = new SimpleDateFormat(DateMode_12);
        try {
            Date startDate = simpleDateFormat.parse(startDateStr); // 开始日期
            Date endDate = simpleDateFormat.parse(endDateStr); //结束日期
            Calendar startCalendar = Calendar.getInstance();
            Calendar endCalendar = Calendar.getInstance();
            startCalendar.setTime(startDate);
            endCalendar.setTime(endDate);
            while (startCalendar.compareTo(endCalendar) < 0) {
                list.add(format.format(startCalendar.getTime()));
                // 开始日期加一个小时直到等于结束日期为止
                startCalendar.add(Calendar.HOUR, 1);
            }
        } catch (ParseException e) {

        }
        return list;
    }
    /**
     * 获取两个日期之间的所有每隔15分钟的节点集合
     * @param startDateStr
     * @param endDateStr
     * @return
     */
    public static List<String> getMinuterList(String startDateStr, String endDateStr) {
        List<String> list = new ArrayList<>();
        DateFormat simpleDateFormat = new SimpleDateFormat(DateMode_2);
        DateFormat format = new SimpleDateFormat(DateMode_12);
        try {
            Date startDate = simpleDateFormat.parse(startDateStr); // 开始日期
            Date endDate = simpleDateFormat.parse(endDateStr); //结束日期
            Calendar startCalendar = Calendar.getInstance();
            Calendar endCalendar = Calendar.getInstance();
            startCalendar.setTime(startDate);
            endCalendar.setTime(endDate);
            while (startCalendar.compareTo(endCalendar) <= 0) {
                list.add(format.format(startCalendar.getTime()) );
                // 开始日期加一个小时直到等于结束日期为止
                startCalendar.add(Calendar.MINUTE, 15);
            }
        } catch (ParseException e) {

        }
        return list;
    }
    /**
     * 获取当前时间前n分钟
     *
     * @param n
     * @return
     */
    public static String beforeForNowDate(int n) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MINUTE, (calendar.get(Calendar.MINUTE) - n));
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        return df.format(calendar.getTime());
    }


    public static Date  getTimeBeforeForNowDate(int n) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MINUTE, (calendar.get(Calendar.MINUTE) - n));
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
        return calendar.getTime();
    }

    /**
     * 获取当前时间后n分钟
     *
     * @param n
     * @return
     */
    public static String afterForNowDate(int n) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MINUTE, (calendar.get(Calendar.MINUTE) + n));
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        return df.format(calendar.getTime());
    }

    public static Date pase13LongTime(Long time) {
        Date date = new Date();
        if(null == time){
           return date ;
        }
        try {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
            String result2 = df.format(Double.valueOf(time));
            Date parse = df.parse(result2);
            return parse ;
        } catch (ParseException e) {

            return date ;
        }
    }

    /**
     * 如果是整点：08:00，返回08
     * 如果不是整点：08:09，返回08:09
     *
     * @param date
     * @return
     */
    private String getTime(Date date) {
        if (cn.hutool.core.date.DateUtil.minute(date) == 0) {
            return getHour(date);
        }
        return formatToMinute(date);
    }
    /**
     * 获取前/后?分钟
     * 返回时间类型
     *
     * @param d
     * @param minute
     * @return
     */
    public static Date rollMinute(Date d, int minute) {
        return new Date(d.getTime() + minute * 60 * 1000);
    }

    /**
     * 获取前/后？分钟
     * 返回字符串类型
     * @param d
     * @param minute
     * @return
     * @throws ParseException
     */
    public static String rollMinuteToStr(String d, int minute) throws ParseException {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm");
        Date times =simpleDateFormat.parse(d);
        return simpleDateFormat.format(new Date(times.getTime() + minute * 60 * 1000)) ;
    }

    /**
     * 获取前/后 ？秒
     * 返回字符串类型
     * @param d
     * @param minute
     * @return
     * @throws ParseException
     */
    public static Date rollSecondToStr(int minute) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND,minute);
        String time = simpleDateFormat.format(calendar.getTime());
        return simpleDateFormat.parse(time);
    }



    /**
     * 获取下一月
     * @return
     */
    public static String getNextMonth(){
        Calendar cal = Calendar.getInstance();
        cal.add(cal.MONTH, 1);
        SimpleDateFormat dft = new SimpleDateFormat("yyyyMM");
        String preMonth = dft.format(cal.getTime());
        return preMonth;
    }



    /**
     * 获取两个日期之间的所有月份 (年月)
     *
     * @param startTime
     * @param endTime
     * @return：list
     */
    public static List<String> getMonthBetweenDate(String startTime, String endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        // 声明保存日期集合
        List<String> list = new ArrayList<>();
        try {
            // 转化成日期类型
            Date startDate = sdf.parse(startTime);
            Date endDate = sdf.parse(endTime);

            //用Calendar 进行日期比较判断
            Calendar calendar = Calendar.getInstance();
            while (startDate.getTime() <= endDate.getTime()) {

                // 把日期添加到集合
                list.add(sdf.format(startDate));

                // 设置日期
                calendar.setTime(startDate);

                //把月数增加 1
                calendar.add(Calendar.MONTH, 1);

                // 获取增加后的日期
                startDate = calendar.getTime();
            }
        } catch (Exception e) {
            ;
        }
        return list;
    }

    public static void main(String[] args) {

        Date s = null;
        try {
            s = DateUtil.rollSecondToStr(-5);
        } catch (ParseException e) {
            ;
        }
        System.out.println(s);
    }
}
